Shuffle system, shuffle method, and program

ABSTRACT

The number of permutations is reduced when four-party shuffling is performed. Among four secure computation nodes holding first to third shares of data in a secret-shared form, first and second secure computation nodes are selected as resharing nodes, and third and fourth secure computation nodes are selected as receiving nodes. The first and second secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that third and fourth receiving nodes do not know. Next, the third and fourth secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that first and second receiving nodes do not know.

This application is a National Stage Entry of PCT/JP2019/046572 filed on Nov. 28, 2019, the contents of all of which are incorporated herein by reference, in their entirety.

FIELD

The present invention relates to a shuffle system, a shuffle method, and a program.

BACKGROUND

Patent Literature (PTL) 1 discloses a secure computation method that achieves secure computation including secret random permutations at high-speed. In addition, as an application of such secure computation, there is database processing in which data and queries are kept secret. In addition, a sorting protocol is used as an important sub-protocol to realize database operations on the secure computation. PTL2 discloses a sorting algorithm that is not based on comparison.

There are several methods for realizing the above sorting protocol. Two typical schemes are as follows.

A scheme based on a sorting network A scheme using shuffling (random permutations)

The scheme using shuffling needs less cost, and PTLs 1 and 2 both adopt this scheme. Two typical examples of the scheme using shuffling (random permutations) are as follows.

A semi-honest security scheme using three-party (ring) replicated secret sharing (see Non Patent Literature (NPL) 1) A semi-honest security/malicious security scheme using N-party (field) additive secret sharing (see NPL2)

-   PTL1: International Publication No. 2015/107952 -   PTL2: Japanese Unexamined Patent Application No. 2012-154990 -   NPL1: IKARASHI Dai, et al., “A Design and an Implementation of     Super-high-speed Multi-party Sorting: The Day When Multi-party     Computation Reaches Scripting Languages”, Computer Security     Symposium 2017, proceedings 2017.2 (2017) -   NPL2: Sven Laur, Jan Willemson, and Bingsheng Zhang,     “Round-efficient oblivious database manipulation”, International     Conference on Information Security, Springer, Berlin, Heidelberg,     2011, [searched on Nov. 1, 2019], Internet     <URL:https://eprint.iacr.org/2011/429.pdf>

SUMMARY

The following analysis has been made by the present inventor. In accordance with the scheme in NPL1, since three-party secret sharing is performed, only two permutations are needed per round. However, if four-party secret sharing is performed, the number of permutations is increased, which is a problem. For example, NPL2 discloses that, when N-party secret sharing is performed, the number of permutations based on the number of parties is needed (see “4.1 Oblivious Shuffle based on Permutation Matrices” in NPL2).

It is an object of the present invention to provide a shuffle system, a shuffle method, and a program that can reduce the number of permutations in four-party shuffling, thereby contributing to reduce the computation cost.

According to a first aspect, there is provided a shuffle system, that is configured to select, among four secure computation nodes holding first to third shares of data in a secret-shared form, first and second secure computation nodes as resharing nodes and third and fourth secure computation nodes as receiving nodes; and shuffle the shares. Concretely, the first and second secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that the third and fourth receiving nodes do not know. Then, the first secure computation node transmits a first share to the third secure computation node, the first secure computation node transmits a difference between the first share and a second share to the fourth secure computation node, the second secure computation node transmits a third share to the third secure computation node, and the second secure computation node transmits a difference between the second share and the third share to the fourth secure computation node, as a first round. Next, the third and fourth secure computation nodes perform a mini-shuffle for resharing the share(s) they each hold by using a permutation that the first and second receiving nodes do not know. Then, the third secure computation node transmits a first share to the first secure computation node, the fourth secure computation node transmits a difference between the first share and a second share to the first secure computation node, the third secure computation node transmits a third share to the second secure computation node, and the fourth secure computation node transmits a difference between the second share and the third share to the second secure computation node, as a second round.

According to a second aspect, there is provided a shuffle method wherein shuffling shares is performed in a configuration that, among four secure computation nodes holding first to third shares of data in a secret-shared form, first and second secure computation nodes are selected as resharing nodes and third and fourth secure computation nodes are selected as receiving nodes. Concretely, the first and second secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that the third and fourth receiving nodes do not know. Then, the first secure computation node transmits a first share to the third secure computation node, the first secure computation node transmits a difference between the first share and a second share to the fourth secure computation node, the second secure computation node transmits a third share to the third secure computation node, and the second secure computation node transmits a difference between the second share and the third share to the fourth secure computation node, as a first round. Next, the third and fourth secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that the first and second receiving nodes do not know. Then, the third secure computation node transmits a first share to the first secure computation node, the fourth secure computation node transmits a difference between the first share and a second share to the first secure computation node, the third secure computation node transmits a third share to the second secure computation node, and the fourth secure computation node transmits a difference between the second share and the third share to the second secure computation node, as a second round. The present method is associated with certain machines referred to as the secure computation nodes configured by the four secure computation nodes.

According to a third aspect, there is provided a (computer) program for realizing the functions of the above secure computation nodes. This program can be inputted to a computer apparatus via an input device or a communication interface from the outside, be stored in a storage device, cause a processor to drive in accordance with predetermined steps or processes, and display, as needed, a result of the processes including an intermediate state per stage on a display device or communicate with the outside via the communication interface. For example, the computer apparatus for this purpose typically includes a processor, a storage device, an input device, a communication interface, and a display device as needed, which can be connected to each other via a bus. In addition, this program can be a recorded in a computer-readable (non-transitory) storage medium.

According to the present invention, there are provided a shuffle system, a shuffle method, and a program that can reduce the number of permutations in four-party shuffling, thereby contributing to reduce the computation cost.

BRIEF DESCRIPTION OF DRAWINGS

FIG. 1 is a diagram illustrating a configuration according to an example embodiment of the present invention.

FIG. 2 is a diagram illustrating an operation according to the example embodiment of the present invention.

FIG. 3 is a diagram illustrating an operation according to the example embodiment of the present invention.

FIG. 4 is a diagram illustrating a configuration of a shuffle system according to a first example embodiment of the present invention.

FIG. 5 is a diagram illustrating a configuration of a secure computation server according to the first example embodiment of the present invention.

FIG. 6 is a diagram illustrating an example of a mini-shuffle execution order according to the first example embodiment of the present invention.

FIG. 7 is a diagram illustrating an operation in a round (i=1) according to the first example embodiment of the present invention.

FIG. 8 is a diagram illustrating an operation in a round (i=2) according to the first example embodiment of the present invention.

FIG. 9 is a diagram illustrating a configuration of a computer that configures a secure computation server according to the present invention.

PREFERRED MODES

First, an outline of an example embodiment of the present invention will be described with reference to drawings. In the following outline, various components are denoted by reference characters for the sake of convenience. That is, the following reference characters are merely used as examples to facilitate understanding of the present invention. Thus, the description of the outline is not meant to limit the present invention to the illustrated modes. An individual connection line between blocks in the drawings, etc. referred to in the following description signifies both one-way and two-way directions. An arrow schematically illustrates a principal signal (data) flow and does not exclude bidirectionality. A program is executed on a computer apparatus, and the computer apparatus includes, for example, a processor, a storage device, an input device, a communication interface, and as needed, a display device. In addition, this computer apparatus is configured such that the computer apparatus can communicate with its internal device or an external device (including a computer) via the communication interface in a wired or wireless manner. In addition, while a port or an interface is present at an input/output connection point of an individual block in the relevant drawings, illustration of the port or the interface is omitted. In addition, in the following description, “A and/or B” signifies A or B, or A and B.

As illustrated in FIG. 1 , an example embodiment of the present invention can be realized by a shuffle system including four secure computation nodes 10-1 to 10-4 that holds data in a secret-shared form as first to third shares. The shares are shuffled by selecting, among these four secure computation nodes 10-1 to 10-4, first and second secure computation nodes as resharing nodes and third and fourth secure computation nodes as receiving nodes.

More concretely, the first and second secure computation nodes perform a mini-shuffle, respectively, for resharing share(s) they each hold by using a permutation(s) that the third and fourth receiving nodes do not know. The following description assumes that the secure computation nodes 10-1 and 10-2 in FIG. 2 are selected as the resharing nodes and the secure computation nodes 10-3 and 10-4 are selected as the receiving nodes.

After the mini-shuffle, as illustrated in FIG. 2 , the secure computation node 10-1 transmits a first share y1 to the secure computation node 10-3 and transmits a difference M1 between the first share and the second share to the secure computation node 10-4.

In contrast, the secure computation node 10-2 transmits a third share y3 to the secure computation node 10-3 and transmits a difference M2 between the second share and the third share to the secure computation node 10-4. The above processes are performed in the first round.

In the second round, the resharing nodes and the receiving nodes are switched. In FIG. 3 , the secure computation nodes 10-3 and 10-4 are selected as the resharing nodes, and the secure computation nodes 10-1 and 10-2 is to be the receiving nodes.

As in the first round, the secure computation nodes 10-3 and 10-4 perform a mini-shuffle, respectively, for resharing share(s) they each hold by using a permutation(s) that the receiving nodes 10-1 and 10-2 do not know.

After performing the mini-shuffles, as illustrated in FIG. 3 , the secure computation node 10-3 transmits the first share y1 to the secure computation node 10-1 and transmits the third share y3 to the secure computation node 10-2.

In contrast, the secure computation node 10-4 transmits the difference M1 between the first share and the second share to the secure computation node 10-1 and transmits the difference M2 between the second share and the third share to the secure computation node 10-2. The above processes are performed in the second round.

As described above, according to the present example embodiment, the shares can be shuffled by performing two times of round in which the number of permutations is two.

First Example Embodiment

Next, a first example embodiment of the present invention will be described in detail with reference to drawings. FIG. 4 is a diagram illustrating a configuration of a shuffle system according to the first example embodiment of the present invention. FIG. 4 illustrates a configuration in which four secure computation servers P₁ to P₄, which function as the secure computation nodes described above, are connected to each other. Unless a particular secure computation server is specified, any one of the secure computation servers will also be referred to as a secure computation server P_(i).

Hereinafter, the notation used in the following description will be defined. The fourth line in the following [Math. 1] describes a finite ring, and the fifth line in the following [Math. 1] describes a pseudorandom function. S_(m) represents a set of permutations applied to m elements, and π represents an arbitrary permutation belonging to S_(m). Among the permutations. belonging to S_(m), i.e. the set of permutations applied to m elements, [π]_(i) represents a permutation that only P_(i) and P_(i+1) know.

The i-th party: P _(i) (i=1,2,3,4)

Security parameter: κ

The i-th seed: seed_(i)∈{0,1}^(κ)

A finite ring:

s.t.|

| is k-bits and its order is R.

A pseudorandom function: H:{0,1}*×{0,1}*→{0,1}^(k)

The vector of shares: [{right arrow over (x)}]^(m)=([x ₁], . . . ,[x _(m)])

All permutations of a set with m elements: S _(m)

A permutation of a set with m elements: π∈S _(m)

Only P _(i) and P _(i+1) know a permutation π: [π]_(i)  [Math. 1]

Hereinafter, the vector of an arbitrary element x will be expressed not only by an arrow over the element x but also by [vec{x}]. For example, an m dimensional vector of share x in the above [Math. 1] will also be expressed by [vec{x}]^(m). In addition, {0,1}* represents a bit string of arbitrary length.

FIG. 5 is a diagram illustrating a configuration of a secure computation server according to the first example embodiment of the present invention. FIG. 5 illustrates a configuration including a permutation generation part 101, a permutation application part 102, an arithmetic operation part 103, a random value computation part 105, a hash value computation part 106, a seed storage part 107, and a share value storage part 108.

The permutation generation part 101 generates a permutation(s) [π]_(i) that only P_(i) and P_(i+1) know, in coordination with other secure computation server(s) P_(i). For example, the secure computation server P₁ holds [π]₁ and [π]₄, but not information about [π]₂ and [π]₃.

The permutation application part 102 takes a m dimensional vector [vec{x}]^(m) of the above share(s) x and the permutation(s) [π]_(i) as input, and outputs [vec{y}]^(m) obtained by permutating [vec{x}]^(m). An example of concrete processes of the permutation application part 102 will be described below along with an operation according to the present example embodiment.

The arithmetic operation part 103 performs computation of the m dimensional vector [vec{x}]^(m) of the share(s) of x and random values computed by the random value computation part 105, for example. An example of concrete processes of the arithmetic operation part 103 will be described below along with an operation according to the present example embodiment.

The random value computation part 105 generates two random values by using a seed(s) held in the seed storage part 107 and transmits the random values to the hash value computation part 106.

The hash value computation part 106 computes hash values of the random values computed by the random value computation part 105. According to the present example embodiment, these hash values are used as random values.

The seed storage part 107 stores the seeds used for generating random values as described above. The present example embodiment assumes that the seeds have previously been distributed to the secure computation servers P₁ to P₄ as follows.

P ₁:(seed₁,seed₂,seed₄)

P ₂:(seed₂,seed₃,seed₄)

P ₃:(seed₃,seed₁,seed₄)

P ₄:(seed₁,seed₂,seed₃)

The share value storage part 108 holds the m dimensional vector of share(s) as a permutation target(s). The following description will be made assuming that the individual secure computation servers P₁ to P₄ shared and hold shares of x, based on a 2-out-of-4 secret sharing scheme, as will be described below. Herein, x represents the elements of a finite ring R, and x₁, x₂, and x₃ are randomly generated such that x₁+x₂+x₃ satisfies x (mod R). Hereinafter, the share(s) of x will be denoted by [x], and the shares held by the secure computation server P_(i) will be denoted by [x]i.

P ₁:[X]₁=(x ₁ ,x ₂)

P ₂:[x]₂=(x ₂ ,x ₃)

P ₃:[x]₃=(x ₃ ,x ₁)

P ₄:[x]₄=(x ₁ −x ₂ ,x ₂ −x ₃)

Next, an operation according to the present example embodiment will be described in detail with reference to drawings. According to the present example embodiment, a round performing a mini-shuffle, in which two of the secure computation servers P₁ to P₄ operate as resharing nodes and the other two secure computation servers operate as receiving nodes, is repeated at least two times, thereby, a shuffle of the shares of x, which are the m dimensional vector [vec{x}]^(m), is performed.

FIG. 6 is a diagram illustrating an example of a mini-shuffle execution order according to the first example embodiment of the present invention. As illustrated in FIG. 6 , first, in case of i=1, P₃ and P₄, which are P_(i+2) and P_(i+3) operate as the receiving nodes. Then, P₁ and P₂, which are P_(i) and P_(i+1), perform a mini-shuffle with [π₁]₁ as the resharing nodes. Next, in a round of i=3, P₁ and P₂, which are P_(i+2) and P_(i+3), operate as the receiving nodes. Then, a mini-shuffle with [π₂]₃ is performed by causing P₃ and P₄, which are P_(i) and P_(i+1), perform a mini-shuffle with [π₂]₃ as the resharing nodes. A shuffle is completed by the above two rounds.

Next, details of the processes performed in the individual round will be described in order.

[Round 1 i=1] FIG. 7 is a diagram illustrating an operation in a round (i=1). In round 1, the secure computation servers P₃ and P₄ operate as the receiving nodes. In addition, the secure computation servers P₁ and P₂ operate as the resharing nodes. The mini-shuffle in round 1 is expressed by the following expression [Math. 2].

[{right arrow over (y)}]^(m)←MiniShuffle(1,[{right arrow over (x)}]^(m),[π₁]₁)  [Math. 2]

[vec{x}]^(m) on the right-hand side represents the m dimensional vector in which the share(s) x is (are) secret-shared and is expressed by [x₁], . . . , [x_(m)]. In practice, as described above, x_(j) is secret-shared in the secure computation server P_(i) such that x_(j)=x_(j, 1)+x_(j, 2)+x_(j, 3) (j=1, . . . , m) is satisfied. [π]₁ on the right-hand side is a permutation [π]₁ that only the secure computation servers P₁ and P₂ know.

An output [vec{y}]^(m) obtained from the above right-hand side content as the input is a result of a single mini-shuffle using the permutation [π]₁ and is expressed by [y_(π1(1))], . . . , [y_(π1(m))]. y_(π1 (j)) in this output is also shared and hold in the secure computation server P_(i) such that y_(π1(j))=y_(π1(j),1)+y_(π1(j),2)+y_(π1(j), 3) (j=1, . . . , m) is satisfied, as described above.

The following expression [Math. 3] illustrates the above mini-shuffle procedure.

[Math. 3]

P ₁ and P ₂ generate the random values r _(j,1) and r _(j,2) . r _(j,1) =H(vid ₁∥1∥_(j), seed₂∥seed₄) r _(j,2) =H(vid ₁∥2∥_(j), seed₂∥seed₄)  1.

Here, we set that y _(π) ₁ _((j)) =y _(π) ₁ _((j),1) +y _(π) ₁ _((j),2) +y _(π) ₁ _((j),3)(mod R).  2.

P ₁ computes y _(π) ₁ _((j),1) and y _(π) ₁ _((j),2) . y _(π) ₁ _((j),1) =x _(π) ₁ _((j),1) −r _(j,1) y _(π) ₁ _((j),2) =x _(π) ₁ _((j),2) −r _(j,1) =r _(j,2)  3.

P ₂ compute y _(π) ₁ _((j),2) and y _(π) ₁ _((j),3) . y _(π) ₁ _((j),2) =x _(π) ₁ _((j),2) +r _(j,1) +r _(j,2) y _(π) ₁ _((j),3) =x _(π) ₁ _((j),3) −r _(j,2)  4.

P ₁ sends {right arrow over (y ₁)} to P ₃ and P ₂ sends {right arrow over (y ₃)} to P ₃ . P ₁ sends {right arrow over (m _(1,1))}={right arrow over (y ₁)}−{right arrow over (y ₂)} to P ₄ and P ₂ sends {right arrow over (m _(2,2))}={right arrow over (y ₂)}−{right arrow over (y ₃)} to P ₄. {right arrow over (y _(i))}=(y _(π) ₁ _((1),i) , . . . ,yπ1(m),i)  5.

(Step 1-1) First, the secure computation servers P₁ and P₂ generate two random values r_(j,1) and r_(j,2) by using previously distributed seeds, seed₂ and seed₄. (Step 1-2 to 1-4) Next, the secure computation servers P₁ and P₂ compute y_(π1(j), 1), y_(π1(j), 2), and y_(π1(j), 3) such that y_(π1(j))=y_(π1(j), 1)+y_(π1(j), 2)+y_(π1(j), 3) (mod R) is satisfied by using the random values r_(j,1) and r_(j,2) in coordination with each other. Concretely, y_(π1(j), 1), y_(π1(j),2), and y_(π1(j),3) are computed as follows.

y _(π1(j),1) =x _(π1(j),1) −r _(j,1)

y _(π1(j),2) =x _(π1(j),2) +r _(j,1) +r _(j,2)

y _(π1(j),3) =x _(π1(j),3) −r _(j,2)

(Step 1-5) Next, the secure computation servers P₁ and P₂ transmit their computation results to the secure computation servers P₃ and P₄ operating as the receiving nodes (see FIG. 7 ). Concretely, the secure computation server P₁ transmits vec{y₁} to the secure computation server P₃. The secure computation server P₂ transmits vec{y₃} to the secure computation server P₃. In addition, the secure computation server P₁ transmits vec{y₁}−vec{y₂} as vec{m_(1,1)} to the secure computation server P₄. In addition, the secure computation server P₂ transmits vec{y₂}−vec{y₃} as vec{m_(2, 2)} to the secure computation server P₄. As expressed by [Math. 3], y_(i) is the m dimensional vector, for example, expressed by ([y_(π1(1), i)] . . . , [y_(π1 (m),i)]).

As a result of the above mini-shuffle, the secure computation servers P₁ to P₄ hold a mini-shuffled m dimensional vector, as expressed by the following expression [Math. 4].

$\begin{matrix} \begin{matrix} {{P_{1}:\left( {\overset{\longrightarrow}{y_{1}},\overset{\longrightarrow}{y_{2}}} \right)} = {\left( {\left( {y_{{\pi_{1}(1)},1},y_{{\pi_{1}(1)},2}} \right),\ldots,\left( {y_{{\pi_{1}(m)},1},y_{{\pi_{1}(m)},2}} \right)} \right) = \left( {\left\lbrack y_{\pi_{1}(1)} \right\rbrack_{1},\ldots,\left\lbrack y_{\pi_{1}(m)} \right\rbrack_{1}} \right)}} \\ {{P_{2}:\left( {\overset{\longrightarrow}{y_{2}},\overset{\longrightarrow}{y_{3}}} \right)} = {\left( {\left( {y_{{\pi_{1}(1)},2},y_{{\pi_{1}(1)},3}} \right),\ldots,\left( {y_{{\pi_{1}(m)},2},y_{{\pi_{1}(m)},3}} \right)} \right) = \left( {\left\lbrack y_{\pi_{1}(1)} \right\rbrack_{2},\ldots,\left\lbrack y_{\pi_{1}(m)} \right\rbrack_{2}} \right)}} \\ {{P_{3}:\left( {\overset{\longrightarrow}{y_{3}},\overset{\longrightarrow}{y_{1}}} \right)} = {\left( {\left( {y_{{\pi_{1}(1)},3},y_{{\pi_{1}(1)},1}} \right),\ldots,\left( {y_{{\pi_{1}(m)},3},y_{{\pi_{1}(m)},1}} \right)} \right) = \left( {\left\lbrack y_{\pi_{1}(1)} \right\rbrack_{3},\ldots,\left\lbrack y_{\pi_{1}(m)} \right\rbrack_{3}} \right)}} \\ {{P_{4}:\left( {\overset{\longrightarrow}{m_{1,1}},\overset{\longrightarrow}{m_{2,2}}} \right)} = \left( {{\overset{\longrightarrow}{y_{1}} - \overset{\longrightarrow}{y_{2}}},{\overset{\longrightarrow}{y_{2}} - \overset{\longrightarrow}{y_{3}}}} \right)} \\ {= \left( {\left( {{y_{{\pi_{1}(1)},1} - y_{{\pi_{1}(1)},2}},{y_{{\pi_{1}(1)},2} - y_{{\pi_{1}(1)},3}}} \right),\ldots,\left( {{y_{{\pi_{1}(m)},1} - y_{{\pi_{1}(m)},2}},{y_{{\pi_{1}(m)},2} - y_{{\pi_{1}(m)},3}}} \right)} \right)} \\ {= \left( {\left\lbrack y_{\pi_{1}(1)} \right\rbrack_{4},\ldots,\left\lbrack y_{\pi_{1}(m)} \right\rbrack_{4}} \right)} \end{matrix} & \left\lbrack {{Math}.4} \right\rbrack \end{matrix}$

[Round 2 i=2]

FIG. 8 is a diagram illustrating an operation in a round (i=2). In round 2, the secure computation servers P₁ and P₂ operate as the receiving nodes. In addition, the secure computation servers P₃ and P₄ operate as the resharing nodes. The mini-shuffle in round 2 is expressed by the following expression [Math. 5].

[{right arrow over (y)}]^(m)←MiniShuffle(2,[{right arrow over (x)}]^(m),[π₂]₃)  [Math. 5]

[π]₃ on the right-hand side is a permutation [π]₁ that only the secure computation servers P₃ and P₄ know.

An output [vec{y}]^(m) obtained from the above right-hand side content as the input is a result of a single mini-shuffle using the permutation [π]₃ and is expressed by [y_(π2(1))], . . . , [y_(π2 (m))]. y_(π2(j)) in this output is also secret-shared in the secure computation server P_(i) such that y_(π2 (j))=y_(π2 (j), 1)+y_(π2 (j),2)+y_(π2 (j), 3) (j=1, . . . , m) is satisfied, as described above.

The following expression [Math. 6] illustrates the above mini-shuffle procedure.

[Math. 6]

P ₃ and P ₄ generate the random values r _(j,1) and r _(j,2) . r _(j,1) =H(vid ₁∥1∥_(j),seed₂∥seed₃) r _(j,2) =H(vid ₁∥2∥_(j),seed₂∥seed₃)  1.

Here, we set that y _(π) ₂ _((j)) =y _(π) ₂ _((j),1) +y _(π) ₁ _((j),2) +y _(π) ₂ _((j),3)(mod R).  2.

P ₃ computes y _(π) ₂ _((j),1) and y _(π) ₂ _((j),3).  3.

P ₄ compute y _(π) ₂ _((j),1) −y _(π) ₂ _((j),2) and y _(π) ₂ _((j),2) −y _(π) ₂ _((j),3) as follows: y _(π) ₄ _((j),1) −y _(π) ₄ _((j),2)=(x _(π) ₄ _((j),1) −x _(π) ₄ _((j),1))−2r _(j,1) −r _(j,2) y _(π) ₄ _((j),2) −y _(π) ₄ _((j),3)=(x _(π) ₄ _((j),2) −x _(π) ₄ _((j),3))+r _(j,1)+2r _(j,2)  4.

P ₃ sends {right arrow over (y ₁)} to P ₁ and {right arrow over (y ₃)} to P ₂ . P ₄ sends {right arrow over (m _(2,4))}={right arrow over (y ₁)}−{right arrow over (y ₂)} to P ₁ and {right arrow over (m _(1,4))}={right arrow over (y ₂)}−{right arrow over (y ₃)} to P ₂. {right arrow over (y ₁)}=(y _(π) ₁ _((1),i) , . . . ,y _(π) ₁ _((m),i))  5.

(Step 2-1) First, the secure computation servers P₃ and P₄ generate two random values r_(j,1) and r_(j, 2) by using previously distributed seeds, seed₁ and seed₃. (Steps 2-2 to 2-4) Next, the secure computation servers P₃ and P₄ compute y_(π2 (j), 1), y_(π2(j), 2), and y_(π2(j), 3) such that y_(π2 (j))=y_(π2(j), 1)+y_(π2(j), 2)+y_(π2(j), 3) (mod R) is satisfied by using the random values r_(j,1) and r_(j, 2) in coordination with each other. Concretely, the secure computation servers P₃ and P₄ compute y_(π2 (j), 1), y_(π2 (j), 2), and y_(π2(j), 3) as follows.

y _(π2(j),1) =x _(π2(j),1) −r _(j,1)

y _(π2(j),1) =x _(π2(j),1) +r _(j,1) +r _(j,2)

y _(π2(j),3) =x _(π2(j),3) −r _(j,2)

In addition, the secure computation server P₄ computes y_(π2(j), 1)−y_(π2(j), 2) and y_(π2(j), 2)−y_(π2(j), 3) as expressed by [Math. 6].

(Step 2-5) Next, the secure computation servers P₃ and P₄ transmit their computation results to the secure computation servers P₁ and P₂ operating as the receiving nodes (see FIG. 8 ). Concretely, the secure computation server P₃ transmits vec{y₁} to the secure computation server P₁ and transmits vec{y₃} to the secure computation server P₂. In addition, the secure computation server P₄ transmits vec{y₁}−vec{y₂} as vec{m_(2,4)} to the secure computation server P₁. In addition, the secure computation server P₄ transmits vec{y₂}−vec{y₃} as vec{m_(1, 4)} to the secure computation server P₂. As expressed by [Math. 6], y_(i) is the m dimensional vector, for example, expressed by ([y_(π2(1),i)], . . . , [y_(π2(m),i)]).

As a result of the above mini-shuffle, the secure computation servers P₁ to P₄ hold a mini-shuffled m dimensional vector, as expressed by the following expression [Math. 7].

$\begin{matrix} \begin{matrix} {{P_{1}:\left( {\overset{\longrightarrow}{y_{1}},{\overset{\longrightarrow}{- m_{2,4}} + \overset{\longrightarrow}{y_{1}}}} \right)} = {\left( {\left( {y_{{\pi_{2}(1)},1},y_{{\pi_{2}(1)},2}} \right),\ldots,\left( {y_{{\pi_{2}(m)},1},y_{{\pi_{2}(m)},2}} \right)} \right) = \left( {\left\lbrack y_{\pi_{2}(1)} \right\rbrack_{1},\ldots,\left\lbrack y_{\pi_{2}(m)} \right\rbrack_{1}} \right)}} \\ {{P_{2}:\left( {{\overset{\longrightarrow}{m_{1,4}} + \overset{\longrightarrow}{y_{3}}},\overset{\longrightarrow}{y_{3}}} \right)} = {\left( {\left( {y_{{\pi_{2}(1)},2},y_{{\pi_{2}(1)},3}} \right),\ldots,\left( {y_{{\pi_{2}(m)},2},y_{{\pi_{2}(m)},3}} \right)} \right) = \left( {\left\lbrack y_{\pi_{2}(1)} \right\rbrack_{2},\ldots,\left\lbrack y_{\pi_{2}(m)} \right\rbrack_{2}} \right)}} \\ {{P_{3}:\left( {\overset{\longrightarrow}{y_{3}},\overset{\longrightarrow}{y_{1}}} \right)} = {\left( {\left( {y_{{\pi_{2}(1)},3},y_{{\pi_{2}(1)},1}} \right),\ldots,\left( {y_{{\pi_{2}(m)},3},y_{{\pi_{2}(m)},1}} \right)} \right) = \left( {\left\lbrack y_{\pi_{2}(1)} \right\rbrack_{3},\ldots,\left\lbrack y_{\pi_{2}(m)} \right\rbrack_{3}} \right)}} \\ {P_{4}:\left( {{\overset{\longrightarrow}{y_{1}} - \overset{\longrightarrow}{y_{2}}},{\overset{\longrightarrow}{y_{2}} - \overset{\longrightarrow}{y_{3}}}} \right)} \\ {= \left( {\left( {{y_{{\pi_{2}(1)},1} - y_{{\pi_{2}(1)},2}},{y_{{\pi_{3}(1)},2} - y_{{\pi_{2}(1)},3}}} \right),\ldots,\left( {{y_{{\pi_{2}(m)},1} - y_{{\pi_{3}(m)},2}},{y_{{\pi_{2}(m)},2} - y_{{\pi_{2}(m)},3}}} \right)} \right)} \\ {= \left( {\left\lbrack y_{\pi_{2}(1)} \right\rbrack_{4},\ldots,\left\lbrack y_{\pi_{2}(m)} \right\rbrack_{4}} \right)} \end{matrix} & \left\lbrack {{Math}.7} \right\rbrack \end{matrix}$

By performing the above mini-shuffles, it is possible to perform permutations [π]₁, [π]₃ each once to the inputted [vec{x}]^(m), and a shuffle in a manner that none of the secure computation servers P_(i) can determine the input-output correspondence relationship.

The permutations in the above 2 rounds can be expressed by the following [Math. 8].

[Math. 8]

[{right arrow over (y)}]^(m)←MiniShuffle1 ([{right arrow over (x)}]^(m),[π₁]₁)  1.

[{right arrow over (z)}]^(m)←MiniShuffle2([{right arrow over (y)}]^(m),[π₂]₃)  2.

Furthermore, since a communication of m elements with a security parameter κ bits is performed four times per round, the shuffle cost according to the present example embodiment is 8κm bits in the total for two rounds.

While example embodiments of the present invention have thus been described, the present invention is not limited thereto. Further variations, substitutions, or adjustments can be made without departing from the basic technical concept of the present invention. For example, the connection configurations between devices or apparatuses, the configurations of the elements, and the representation modes of the data illustrated in the drawings have been used only as examples to facilitate understanding of the present invention. That is, the present invention is not limited to the configurations illustrated in the drawings.

For example, an incorrectness or fraud detection function is omitted in the above first example embodiment. However, the incorrectness or fraud detection function can be added by adding any one of various Equality Test Protocols, for example.

Each of the procedures described in the above example embodiments can be realized by a program that causes a computer (9000 in FIG. 9 ) which functions as a corresponding one of the secure computation nodes and the secure computation servers P₁ to realize the function as the corresponding apparatus. This computer includes, for example, a CPU (Central Processing Unit) 9010, a communication interface 9020, a memory 9030, and an auxiliary storage device 9040 in FIG. 9 . That is, the CPU 9010 in FIG. 9 performs the random number generation program and the permutation processing program and performs updating process of each calculation parameters stored in the auxiliary storage device 9040, etc.

That is, the individual parts (processing means, functions) of the secure computation servers P₁ according to the above example embodiments can each be realized by a computer program that causes a processor mounted on the corresponding apparatus to use corresponding hardware and execute each process as described above.

Finally, preferred modes of the present invention will be summarized.

[Mode 1]

(See the shuffle system according to the above first aspect)

[Mode 2]

In the shuffle system, wherein the four secure computation nodes may include: a first secure computation node that holds two seeds (seed₂ and seed₄) and shares (x₁ and x₂) of secret information x in a secret-shared form; a second secure computation node that holds two seeds (seed₂ and seed₄) and shares (x₂ and x₃) of the secret information x in a secret-shared form; a third secure computation node that holds two seeds (seed₁ and seed₃) and shares (x₃ and x₁) of the secret information x in a secret-shared form; and a fourth secure computation node that holds two seeds (seed₁ and seed₃) and shares (x₁−x₂ and x₂−x₃) of the secret information x in a secret-shared form; wherein the resharing nodes may generate two random values by using the corresponding seeds; and wherein the resharing nodes transmit a result, which is obtained by applying a combination of the random values to the share(s) held therein, as a result of the mini-shuffle, to the receiving nodes.

[Mode 3]

(See the shuffle method according to the above second aspect)

[Mode 4]

(See the program according to the above third aspect) The above modes 3 and 4 can be expanded in the same way as mode 1 is expanded to mode 2.

The disclosure of each of the above PTLs and NPLs is incorporated herein by reference thereto and may be used as the basis or a part of the present invention, as needed. Modifications and adjustments of the example embodiments and examples are possible within the scope of the overall disclosure (including the claims) of the present invention and based on the basic technical concept of the present invention. Various combinations or selections (including partial deletion) of various disclosed elements (including the elements in each of the claims, example embodiments, examples, drawings, etc.) are possible within the scope of the disclosure of the present invention. That is, the present invention of course includes various variations and modifications that could be made by those skilled in the art according to the overall disclosure including the claims and the technical concept. The description discloses numerical value ranges. However, even if the description does not particularly disclose arbitrary numerical values or small ranges included in the ranges, these values and ranges should be deemed to have been specifically disclosed. In addition, as needed and based on the gist of the present invention, partial or entire use of the individual disclosed matters in the above literatures that have been referred to in combination with what is disclosed in the present application should be deemed to be included in what is disclosed in the present application, as a part of the disclosure of the present invention.

INDUSTRIAL APPLICABILITY

The present invention is applicable not only to a shuffle system but also to a secret-sharing system in which sorting process using a shuffle function of a shuffle system is performed.

REFERENCE SIGNS LIST

-   10-1 to 10-4 secure computation node -   101 permutation generation part -   102 permutation application part -   103 arithmetic operation part -   105 random value computation part -   106 hash value computation part -   107 seed storage part -   108 share value storage part -   9000 computer -   9010 CPU -   9020 communication interface -   9030 memory -   9040 auxiliary storage device -   P₁ to P₄ secure computation server 

What is claimed is:
 1. A shuffle system, that is configured to: shuffle the shares by performing a first round and a second round; wherein, in the first round, among four secure computation nodes holding first to third shares of data in a secret-shared form, first and second secure computation nodes are selected as resharing nodes and third and fourth secure computation nodes are selected as receiving nodes, the first and second secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that third and fourth receiving nodes do not know, the first secure computation node transmits a first share to the third secure computation node, the first secure computation node transmits a difference between the first share and a second share to the fourth secure computation node, the second secure computation node transmits a third share to the third secure computation node, and the second secure computation node transmits a difference between the second share and the third share to the fourth secure computation node; and wherein, in the second round, the third and fourth secure computation nodes are selected as resharing nodes and the first and second secure computation nodes as receiving nodes, the third and fourth secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that first and second receiving nodes do not know, the third secure computation node transmits a first share to the first secure computation node, the fourth secure computation node transmits a difference between the first share and a second share to the first secure computation node, the third secure computation node transmits a third share to the second secure computation node, and the fourth secure computation node transmits a difference between the second share and the third share to the second secure computation node.
 2. The shuffle system according to claim 1; wherein the four secure computation nodes comprises: a first secure computation node that holds three seeds (seed₁, seed₂, and seed₄) and shares (x₁ and x₂) of secret information x in a secret-shared form; a second secure computation node that holds three seeds (seed₂, seed₃, and seed₄) and shares (x₂ and x₃) of the secret information x in a secret-shared form; a third secure computation node that holds three seeds (seed₃, seed₁, and seed₄) and shares (x₃ and x₁) of the secret information x in a secret-shared form; and a fourth secure computation node that holds three seeds (seed₁, seed₂, and seed₃) and shares (x₁−x₂ and x₂−x₃) of the secret information x in a secret-shared form; wherein the resharing nodes generate two random values by using the seeds; and wherein the resharing nodes transmit a result, which is obtained by applying a combination of the random values to the share(s) held therein, as a result of the mini-shuffle, to the receiving nodes.
 3. A shuffle method, comprising: shuffling the shares by performing a first round and a second round; wherein, in the first round, among four secure computation nodes holding first to third shares of data in a secret-shared form, first and second secure computation nodes are selected as resharing nodes and third and fourth secure computation nodes are selected as receiving nodes, the first and second secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that third and fourth receiving nodes do not know, the first secure computation node transmits a first share to the third secure computation node, the first secure computation node transmits a difference between the first share and a second share to the fourth secure computation node, the second secure computation node transmits a third share to the third secure computation node, and the second secure computation node transmits a difference between the second share and the third share to the fourth secure computation node; and wherein, in the second round, the third and fourth secure computation nodes are selected as resharing nodes and the first and second secure computation nodes are selected as receiving nodes, the third and fourth secure computation nodes perform a mini-shuffle for resharing the shares they each hold by using a permutation that first and second receiving nodes do not know, the third secure computation node transmits a first share to the first secure computation node, the fourth secure computation node transmits a difference between the first share and a second share to the first secure computation node, the third secure computation node transmits a third share to the second secure computation node, and the fourth secure computation node transmits a difference between the second share and the third share to the second secure computation node.
 4. A non-transitory computer-readable medium storing therein a program, causing a first secure computation node in a shuffle system performing a first round and a second round, in the first round, among four secure computation nodes holding first to third shares of data in a secret-shared form, the first secure computation node and a second secure computation node operating as resharing nodes and third and fourth secure computation nodes operating as receiving nodes, and, in the second round, the third and fourth secure computation node operating as resharing nodes and the first and second secure computation nodes operating as receiving nodes, to execute in the first round: a process of performing a mini-shuffle for resharing the share(s) by using a permutation that third and fourth receiving nodes do not know; a process of transmitting a first share to the third secure computation node; and a process of transmitting a difference between the first share and a second share to the fourth secure computation node, and in the second round: a process of receiving a reshared first share from the third secure computation node; and a process of receiving a difference between a reshared first share and a reshared second share from the fourth secure computation node.
 5. A non-transitory computer-readable medium storing therein a program causing a second secure computation node in a shuffle system performing a first round and a second round, in the first round, among four secure computation nodes holding first to third shares of data in a secret-shared form, a first secure computation node and the second secure computation node operating as resharing nodes and third and fourth secure computation nodes operating as receiving nodes, the program being configured to cause the second secure computation node and, in the second round, the third and fourth secure computation node operating as resharing nodes and the first and second secure computation nodes operating as receiving nodes, to execute in the first round: a process of performing a mini-shuffle for resharing the share(s) by using a permutation that third and fourth receiving nodes do not know; a process of transmitting a third share to the third secure computation node; and a process of transmitting a difference between a second share and the third share to the fourth secure computation node, and in the second round a process of receiving a reshared third share from the third secure computation node; and a process of receiving a difference between a reshared second share and a reshared third share from the fourth secure computation node.
 6. The shuffle method according to claim 3; wherein the four secure computation nodes comprises: a first secure computation node that holds three seeds (seed₁, seed₂, and seed₄) and shares (x₁ and x₂) of secret information x in a secret-shared form; a second secure computation node that holds three seeds (seed₂, seed₃, and seed₄) and shares (x₂ and x₃) of the secret information x in a secret-shared form; a third secure computation node that holds three seeds (seed₃, seed₁, and seed₄) and shares (x₃ and x₁) of the secret information x in a secret-shared form; and a fourth secure computation node that holds three seeds (seed₁, seed₂, and seed₃) and shares (x₁−x₂ and x₂−x₃) of the secret information x in a secret-shared form; wherein the resharing nodes generate two random values by using the seeds; and wherein the resharing nodes transmit a result, which is obtained by applying a combination of the random values to the share(s) held therein, as a result of the mini-shuffle, to the receiving nodes.
 7. The non-transitory computer-readable medium according to claim 4; wherein the four secure computation nodes comprises: a first secure computation node that holds three seeds (seed₁, seed₂, and seed₄) and shares (x₁ and x₂) of secret information x in a secret-shared form; a second secure computation node that holds three seeds (seed₂, seed₃, and seed₄) and shares (x₂ and x₃) of the secret information x in a secret-shared form; a third secure computation node that holds three seeds (seed₃, seed₁, and seed₄) and shares (x₃ and x₁) of the secret information x in a secret-shared form; and a fourth secure computation node that holds three seeds (seed₁, seed₂, and seed₃) and shares (x₁−x₂ and x₂−x₃) of the secret information x in a secret-shared form; wherein the resharing nodes generate two random values by using the seeds; and wherein the resharing nodes transmit a result, which is obtained by applying a combination of the random values to the share(s) held therein, as a result of the mini-shuffle, to the receiving nodes.
 8. The non-transitory computer-readable medium according to claim 5; wherein the four secure computation nodes comprises: a first secure computation node that holds three seeds (seed₁, seed₂, and seed₄) and shares (x₁ and x₂) of secret information x in a secret-shared form; a second secure computation node that holds three seeds (seed₂, seed₃, and seed₄) and shares (x₂ and x₃) of the secret information x in a secret-shared form; a third secure computation node that holds three seeds (seed₃, seed₁, and seed₄) and shares (x₃ and x₁) of the secret information x in a secret-shared form; and a fourth secure computation node that holds three seeds (seed₁, seed₂, and seed₃) and shares (x₁−x₂ and x₂−x₃) of the secret information x in a secret-shared form; wherein the resharing nodes generate two random values by using the seeds; and wherein the resharing nodes transmit a result, which is obtained by applying a combination of the random values to the share(s) held therein, as a result of the mini-shuffle, to the receiving nodes. 